// Code generated by MockGen. DO NOT EDIT.
// Source: ../types/tls.go

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	net "net"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	types "mosn.io/mosn/pkg/types"
)

// MockTLSContextManager is a mock of TLSContextManager interface.
type MockTLSContextManager struct {
	ctrl     *gomock.Controller
	recorder *MockTLSContextManagerMockRecorder
}

// MockTLSContextManagerMockRecorder is the mock recorder for MockTLSContextManager.
type MockTLSContextManagerMockRecorder struct {
	mock *MockTLSContextManager
}

// NewMockTLSContextManager creates a new mock instance.
func NewMockTLSContextManager(ctrl *gomock.Controller) *MockTLSContextManager {
	mock := &MockTLSContextManager{ctrl: ctrl}
	mock.recorder = &MockTLSContextManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTLSContextManager) EXPECT() *MockTLSContextManagerMockRecorder {
	return m.recorder
}

// Conn mocks base method.
func (m *MockTLSContextManager) Conn(arg0 net.Conn) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Conn", arg0)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Conn indicates an expected call of Conn.
func (mr *MockTLSContextManagerMockRecorder) Conn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Conn", reflect.TypeOf((*MockTLSContextManager)(nil).Conn), arg0)
}

// Enabled mocks base method.
func (m *MockTLSContextManager) Enabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Enabled indicates an expected call of Enabled.
func (mr *MockTLSContextManagerMockRecorder) Enabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enabled", reflect.TypeOf((*MockTLSContextManager)(nil).Enabled))
}

// MockTLSClientContextManager is a mock of TLSClientContextManager interface.
type MockTLSClientContextManager struct {
	ctrl     *gomock.Controller
	recorder *MockTLSClientContextManagerMockRecorder
}

// MockTLSClientContextManagerMockRecorder is the mock recorder for MockTLSClientContextManager.
type MockTLSClientContextManagerMockRecorder struct {
	mock *MockTLSClientContextManager
}

// NewMockTLSClientContextManager creates a new mock instance.
func NewMockTLSClientContextManager(ctrl *gomock.Controller) *MockTLSClientContextManager {
	mock := &MockTLSClientContextManager{ctrl: ctrl}
	mock.recorder = &MockTLSClientContextManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTLSClientContextManager) EXPECT() *MockTLSClientContextManagerMockRecorder {
	return m.recorder
}

// Conn mocks base method.
func (m *MockTLSClientContextManager) Conn(arg0 net.Conn) (net.Conn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Conn", arg0)
	ret0, _ := ret[0].(net.Conn)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Conn indicates an expected call of Conn.
func (mr *MockTLSClientContextManagerMockRecorder) Conn(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Conn", reflect.TypeOf((*MockTLSClientContextManager)(nil).Conn), arg0)
}

// Enabled mocks base method.
func (m *MockTLSClientContextManager) Enabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Enabled indicates an expected call of Enabled.
func (mr *MockTLSClientContextManagerMockRecorder) Enabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enabled", reflect.TypeOf((*MockTLSClientContextManager)(nil).Enabled))
}

// Fallback mocks base method.
func (m *MockTLSClientContextManager) Fallback() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fallback")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Fallback indicates an expected call of Fallback.
func (mr *MockTLSClientContextManagerMockRecorder) Fallback() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fallback", reflect.TypeOf((*MockTLSClientContextManager)(nil).Fallback))
}

// HashValue mocks base method.
func (m *MockTLSClientContextManager) HashValue() *types.HashValue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HashValue")
	ret0, _ := ret[0].(*types.HashValue)
	return ret0
}

// HashValue indicates an expected call of HashValue.
func (mr *MockTLSClientContextManagerMockRecorder) HashValue() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashValue", reflect.TypeOf((*MockTLSClientContextManager)(nil).HashValue))
}

// MockTLSProvider is a mock of TLSProvider interface.
type MockTLSProvider struct {
	ctrl     *gomock.Controller
	recorder *MockTLSProviderMockRecorder
}

// MockTLSProviderMockRecorder is the mock recorder for MockTLSProvider.
type MockTLSProviderMockRecorder struct {
	mock *MockTLSProvider
}

// NewMockTLSProvider creates a new mock instance.
func NewMockTLSProvider(ctrl *gomock.Controller) *MockTLSProvider {
	mock := &MockTLSProvider{ctrl: ctrl}
	mock.recorder = &MockTLSProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTLSProvider) EXPECT() *MockTLSProviderMockRecorder {
	return m.recorder
}

// Empty mocks base method.
func (m *MockTLSProvider) Empty() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Empty")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Empty indicates an expected call of Empty.
func (mr *MockTLSProviderMockRecorder) Empty() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Empty", reflect.TypeOf((*MockTLSProvider)(nil).Empty))
}

// GetTLSConfigContext mocks base method.
func (m *MockTLSProvider) GetTLSConfigContext(client bool) *types.TLSConfigContext {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTLSConfigContext", client)
	ret0, _ := ret[0].(*types.TLSConfigContext)
	return ret0
}

// GetTLSConfigContext indicates an expected call of GetTLSConfigContext.
func (mr *MockTLSProviderMockRecorder) GetTLSConfigContext(client interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTLSConfigContext", reflect.TypeOf((*MockTLSProvider)(nil).GetTLSConfigContext), client)
}

// MatchedALPN mocks base method.
func (m *MockTLSProvider) MatchedALPN(protos []string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatchedALPN", protos)
	ret0, _ := ret[0].(bool)
	return ret0
}

// MatchedALPN indicates an expected call of MatchedALPN.
func (mr *MockTLSProviderMockRecorder) MatchedALPN(protos interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchedALPN", reflect.TypeOf((*MockTLSProvider)(nil).MatchedALPN), protos)
}

// MatchedServerName mocks base method.
func (m *MockTLSProvider) MatchedServerName(sn string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatchedServerName", sn)
	ret0, _ := ret[0].(bool)
	return ret0
}

// MatchedServerName indicates an expected call of MatchedServerName.
func (mr *MockTLSProviderMockRecorder) MatchedServerName(sn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchedServerName", reflect.TypeOf((*MockTLSProvider)(nil).MatchedServerName), sn)
}

// Ready mocks base method.
func (m *MockTLSProvider) Ready() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ready")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Ready indicates an expected call of Ready.
func (mr *MockTLSProviderMockRecorder) Ready() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockTLSProvider)(nil).Ready))
}

// MockSdsClient is a mock of SdsClient interface.
type MockSdsClient struct {
	ctrl     *gomock.Controller
	recorder *MockSdsClientMockRecorder
}

// MockSdsClientMockRecorder is the mock recorder for MockSdsClient.
type MockSdsClientMockRecorder struct {
	mock *MockSdsClient
}

// NewMockSdsClient creates a new mock instance.
func NewMockSdsClient(ctrl *gomock.Controller) *MockSdsClient {
	mock := &MockSdsClient{ctrl: ctrl}
	mock.recorder = &MockSdsClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSdsClient) EXPECT() *MockSdsClientMockRecorder {
	return m.recorder
}

// AckResponse mocks base method.
func (m *MockSdsClient) AckResponse(resp interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AckResponse", resp)
}

// AckResponse indicates an expected call of AckResponse.
func (mr *MockSdsClientMockRecorder) AckResponse(resp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AckResponse", reflect.TypeOf((*MockSdsClient)(nil).AckResponse), resp)
}

// AddUpdateCallback mocks base method.
func (m *MockSdsClient) AddUpdateCallback(name string, callback types.SdsUpdateCallbackFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddUpdateCallback", name, callback)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddUpdateCallback indicates an expected call of AddUpdateCallback.
func (mr *MockSdsClientMockRecorder) AddUpdateCallback(name, callback interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUpdateCallback", reflect.TypeOf((*MockSdsClient)(nil).AddUpdateCallback), name, callback)
}

// DeleteUpdateCallback mocks base method.
func (m *MockSdsClient) DeleteUpdateCallback(name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUpdateCallback", name)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUpdateCallback indicates an expected call of DeleteUpdateCallback.
func (mr *MockSdsClientMockRecorder) DeleteUpdateCallback(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUpdateCallback", reflect.TypeOf((*MockSdsClient)(nil).DeleteUpdateCallback), name)
}

// FetchSecret mocks base method.
func (m *MockSdsClient) FetchSecret(ctx context.Context, name string) (*types.SdsSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchSecret", ctx, name)
	ret0, _ := ret[0].(*types.SdsSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchSecret indicates an expected call of FetchSecret.
func (mr *MockSdsClientMockRecorder) FetchSecret(ctx, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchSecret", reflect.TypeOf((*MockSdsClient)(nil).FetchSecret), ctx, name)
}

// RequireSecret mocks base method.
func (m *MockSdsClient) RequireSecret(name string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RequireSecret", name)
}

// RequireSecret indicates an expected call of RequireSecret.
func (mr *MockSdsClientMockRecorder) RequireSecret(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequireSecret", reflect.TypeOf((*MockSdsClient)(nil).RequireSecret), name)
}

// SetSecret mocks base method.
func (m *MockSdsClient) SetSecret(name string, secret *types.SdsSecret) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSecret", name, secret)
}

// SetSecret indicates an expected call of SetSecret.
func (mr *MockSdsClientMockRecorder) SetSecret(name, secret interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecret", reflect.TypeOf((*MockSdsClient)(nil).SetSecret), name, secret)
}

// MockSecretProvider is a mock of SecretProvider interface.
type MockSecretProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSecretProviderMockRecorder
}

// MockSecretProviderMockRecorder is the mock recorder for MockSecretProvider.
type MockSecretProviderMockRecorder struct {
	mock *MockSecretProvider
}

// NewMockSecretProvider creates a new mock instance.
func NewMockSecretProvider(ctrl *gomock.Controller) *MockSecretProvider {
	mock := &MockSecretProvider{ctrl: ctrl}
	mock.recorder = &MockSecretProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSecretProvider) EXPECT() *MockSecretProviderMockRecorder {
	return m.recorder
}

// AckResponse mocks base method.
func (m *MockSecretProvider) AckResponse(resp interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AckResponse", resp)
}

// AckResponse indicates an expected call of AckResponse.
func (mr *MockSecretProviderMockRecorder) AckResponse(resp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AckResponse", reflect.TypeOf((*MockSecretProvider)(nil).AckResponse), resp)
}

// SetSecret mocks base method.
func (m *MockSecretProvider) SetSecret(name string, secret *types.SdsSecret) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSecret", name, secret)
}

// SetSecret indicates an expected call of SetSecret.
func (mr *MockSecretProviderMockRecorder) SetSecret(name, secret interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecret", reflect.TypeOf((*MockSecretProvider)(nil).SetSecret), name, secret)
}
